// 测试整个文档解析和卡片生成流程
const DocumentParser = require('./src/services/documentParser');
const CardGenerator = require('./src/services/cardGenerator');
const mongoose = require('mongoose');
const fs = require('fs');
const path = require('path');
require('dotenv').config();

// 测试选项
const TEST_OPTIONS = {
  skipRelationships: true, // 跳过卡片关系构建，避免可能的错误
  cleanupAfterTest: true   // 测试后清理生成的卡片
};

// 简单的测试文档内容
const testDocument = `
# Node.js入门指南

## 1. 什么是Node.js

Node.js是一个基于Chrome V8引擎的JavaScript运行环境。Node.js使用了一个事件驱动、非阻塞式I/O的模型，使其轻量又高效。Node.js的包管理器npm，是全球最大的开源库生态系统。

### 1.1 主要特点

- 非阻塞I/O
- 事件驱动
- 轻量高效
- 单线程
- 跨平台

## 2. Node.js应用场景

Node.js适合开发需要处理大量并发连接但计算强度不高的应用，如：

- 实时聊天应用
- API服务
- 流数据处理
- 微服务架构

### 2.1 不适合的场景

- CPU密集型应用
- 复杂的计算任务
- 需要大量线程的应用

## 3. 安装Node.js

访问官方网站下载安装包：https://nodejs.org/

### 3.1 验证安装

安装完成后，打开终端执行：

\`\`\`bash
node -v
npm -v
\`\`\`

## 4. 第一个Node.js应用

创建一个简单的HTTP服务器：

\`\`\`javascript
const http = require('http');

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello World\\n');
});

server.listen(3000, '127.0.0.1', () => {
  console.log('服务器运行在 http://127.0.0.1:3000/');
});
\`\`\`

保存为app.js，然后运行：

\`\`\`bash
node app.js
\`\`\`
`;

// 模拟文档ID
const mockDocumentId = new mongoose.Types.ObjectId().toString();

// 重写CardGenerator.generateCards方法，以便我们可以控制是否构建关系
const originalGenerateCards = CardGenerator.generateCards;
CardGenerator.generateCards = async function(content, structure, documentId) {
  const cards = [];
  
  // 如果有章节结构，按章节处理
  if (structure && structure.length > 0) {
    for (const chapter of structure) {
      const chapterContent = content.substring(chapter.startIndex, chapter.endIndex);
      
      // 检查章节内容是否为空或太短
      if (!chapterContent || chapterContent.trim().length < 50) {
        console.warn(`章节 "${chapter.title}" 内容太短，跳过`);
        continue;
      }
      
      console.log(`处理章节: ${chapter.title} (长度: ${chapterContent.length})`);
      
      // 使用 AI 模型生成卡片
      const chapterCards = await this.processChapterContentWithAI(chapterContent, chapter.title, documentId);
      
      // 如果 AI 模型失败，使用传统方法
      if (!chapterCards || chapterCards.length === 0) {
        console.warn(`使用 AI 模型处理章节 "${chapter.title}" 失败，使用传统方法`);
        const fallbackCards = await this.processChapterContent(chapterContent, chapter.title, documentId);
        cards.push(...fallbackCards);
      } else {
        cards.push(...chapterCards);
      }
    }
  } else {
    // 没有章节结构，直接处理整个内容
    const defaultChapter = "未分类内容";
    console.log(`处理未分类内容 (长度: ${content.length})`);
    
    // 使用 AI 模型生成卡片
    const defaultCards = await this.processChapterContentWithAI(content, defaultChapter, documentId);
    
    // 如果 AI 模型失败，使用传统方法
    if (!defaultCards || defaultCards.length === 0) {
      console.warn(`使用 AI 模型处理未分类内容失败，使用传统方法`);
      const fallbackCards = await this.processChapterContent(content, defaultChapter, documentId);
      cards.push(...fallbackCards);
    } else {
      cards.push(...defaultCards);
    }
  }
  
  // 根据选项决定是否构建卡片关系
  if (!TEST_OPTIONS.skipRelationships) {
    console.log('构建卡片关系...');
    await this.buildCardRelationships(cards);
  } else {
    console.log('跳过卡片关系构建');
  }
  
  return cards;
};

/**
 * 测试整个文档解析和卡片生成流程
 */
async function testFullProcess() {
  try {
    console.log('开始测试整个文档解析和卡片生成流程...');
    console.log('测试文档长度:', testDocument.length, '字符');
    console.log('测试选项:', TEST_OPTIONS);
    
    // 连接到MongoDB
    await mongoose.connect(process.env.MONGODB_URI);
    console.log('已连接到MongoDB');
    
    // 步骤1: 解析文档结构
    console.log('\n步骤1: 解析文档结构');
    const structure = await DocumentParser.extractStructureWithAI(testDocument);
    console.log('解析出的结构:', JSON.stringify(structure, null, 2));
    
    // 步骤2: 生成知识卡片
    console.log('\n步骤2: 生成知识卡片');
    const cards = await CardGenerator.generateCards(testDocument, structure, mockDocumentId);
    console.log(`成功生成 ${cards.length} 张知识卡片`);
    
    // 步骤3: 显示生成的卡片
    console.log('\n步骤3: 显示生成的卡片');
    cards.forEach((card, index) => {
      console.log(`\n卡片 ${index + 1}/${cards.length}:`);
      console.log(`标题: ${card.title}`);
      console.log(`内容: ${card.content.substring(0, 100)}${card.content.length > 100 ? '...' : ''}`);
      console.log(`章节: ${card.chapter}`);
      console.log(`难度: ${card.difficulty}`);
      console.log(`标签: ${card.tags.join(', ')}`);
    });
    
    // 保存测试结果到文件
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
    const resultFile = path.join(__dirname, `test-result-${timestamp}.json`);
    fs.writeFileSync(resultFile, JSON.stringify({
      structure,
      cards: cards.map(card => ({
        title: card.title,
        content: card.content,
        chapter: card.chapter,
        difficulty: card.difficulty,
        tags: card.tags
      }))
    }, null, 2));
    console.log(`\n测试结果已保存至: ${resultFile}`);
    
    // 清理测试数据
    if (TEST_OPTIONS.cleanupAfterTest) {
      console.log('\n清理测试数据...');
      const Card = require('./src/models/Card');
      await Card.deleteMany({ sourceDocument: mockDocumentId });
      console.log('测试数据已清理');
    } else {
      console.log('\n保留测试数据以供检查');
    }
    
    console.log('\n测试完成!');
  } catch (error) {
    console.error('测试失败:', error);
    console.error('错误堆栈:', error.stack);
  } finally {
    // 恢复原始方法
    CardGenerator.generateCards = originalGenerateCards;
    
    // 断开数据库连接
    if (mongoose.connection.readyState !== 0) {
      await mongoose.disconnect();
      console.log('已断开与MongoDB的连接');
    }
  }
}

// 运行测试
testFullProcess(); 